¿Qué es Tidyverse?

Paquetes y funciones

Flujo de trabajo para el análisis de datos

🌈Tidyverse

Datos: palmerpenguins

• En esta sesión vamos a trabajar con observaciones sobre pingüinos en el archipielago Palmer (Antartida)
• El objetivo del dataset palmerpenguins es proveer muchos datos para hacer ejercicios de manipulación, exploración y análisis de datos.
• Los datos fueron recopilados por Allison Horst y publicados con licencia abierta para su uso.
• Contiene datos sobre especies, islas, largo y profundidad de la cresta, largo de las alas, etc. ?palmerpenguins.

Leyendo datos en R

Fuente: Elaboración propia.

Proyectos y directorios de trabajo

Cuando empiezas a programar para ti mismo:

• Crea un folder dedicado a tu proyecto.
• Inicia un nuevo proyecto de R: File>New Project >Existing Directory
• Se creará un archivo con extensión .RProj.

• El directorio de trabajo se fijará automáticamente.
• Automáticamente se recupera el historial de acciones y los objetos contenidos en el proyecto.
• Es más fácil de reproducir los resultados (path relativo vs. absoluta)

getwd()
setwd()

Estructura de directorios del proyecto

Cada proyecto tiene su propia magia pero yo recomiendo usar la siguiente estructura de directorios:

nombre_proyecto 

├── README.md 
├── codigo 
│ ├── 1_preparacion_datos.Rmd 
│ ├── 2_manipulacion_datos.Rmd 
│ ├── 3_analisis_datos.Rmd 
│ ├── 3_estadistica_descriptiva.Rmd 
│ ├── 4_visualizacion.Rmd 
│ └── lib_func.R 
├── datos 
│ ├── originales 
│ └── procesados 
├── figuras 
└── nombre_proyecto.Rproj

• Nunca guardes los datos manipulados sobre el archivo original.
• Siempre incluye un README.md para saber que es lo que hace este proyecto.

Creación de estructura de directorios de trabajo

Podemos generar la estructura de carpetas directamente desde R:

###########################################################
# Esta función genera una estructura de directorios y
# archivos .Rmd en blanco para comenzar nuestro proyecto. 
#
# El único argumento de entrada es el path. 
###########################################################

plantilla_proyecto <- function(path) {
  # Verificar si el directorio base existe
  if (!dir.exists(path)) {
    stop(paste("El directorio", path, "no existe."))
  }
  
  # Cambiar el directorio de trabajo
  setwd(path)
  
  # Nombre del proyecto
  nombre_proyecto <- "Proyecto_1"
  
  # Crear carpeta principal del proyecto si no existe
  if (!dir.exists(nombre_proyecto)) {
    dir.create(nombre_proyecto)
  }
  
  # Definir estructura de carpetas (sin acentos)
  nombre_subcarpetas <- file.path(nombre_proyecto, c(
    "datos", "codigo", "figuras",    # Carpetas principales
    "datos/original", "datos/procesados" # Subcarpetas
  ))
  
  # Crear todas las carpetas de manera eficiente
  lapply(nombre_subcarpetas, dir.create, recursive = TRUE)
  
  # Crear los archivos dentro de la carpeta "codigo"
  carpeta_codigo <- file.path(nombre_proyecto, "codigo")
  
  # Verificar si la carpeta "codigo" existe antes de crear los archivos
  if (!dir.exists(carpeta_codigo)) {
    stop("La carpeta 'codigo' no existe.")
  }
  
  # Definir nombres de los archivos (sin acentos)
  file_names <- c(
    "1_preparacion_datos",  # Preparación de datos
    "2_manipulacion_datos", # Combinación de datos
    "3_est_descriptiva",    # Descriptivos
    "3_analisis_datos",     # Análisis
    "4_visualizacion"       # Visualización
  )
  
  # Crear las rutas completas para los archivos dentro de "codigo"
  file_paths <- file.path(carpeta_codigo, paste0(file_names, ".Rmd"))
  
  # Crear los archivos
  file.create(file_paths)
  
  # Crear un archivo adicional para funciones auxiliares
  file.create(file.path(carpeta_codigo, "funciones.R"))
  
  message("Estructura del proyecto creada exitosamente.")
}

Función readr()

Para leer/exportar archivos de texto plano en R necesitamos:

• Ubicación de los datos (path).
• delimitador (separador de valores) de los datos p.ej.: ., .``; o |.

Leer archivos de otros formatos

Para importar otros tipos de archivos podemos usar los siguientes paquetes:

• readxl: Archivos en formato MS Excel (Usa Java)
• haven: SPSS, Stata y SAS.
• googlesheets4: Archivos de Google Sheets.
• rvtest: Archivos HTML.

Ejemplo: Importando datos a R

raw_tsv_data <- read_tsv("mi_archivo.tsv")

raw_csv_data <- read_csv("data/original/miarchivo.csv")

# Fuente: https://catalog.data.gov/dataset/electric-vehicle-population-data
electric_vehicles <- read_csv("https://data.wa.gov/api/views/f6w7-q2d2/rows.csv")

Uso de tibbles en 🌈 Tidyverse

• La mayoría de las funciones en Tidyverse producen resultados en objetos denominados tibbles.
• Los tibbles son en escencia similares a los dataframe pero no son lo mismo:
  • Hacen menos cosas:
    • Nunca convierten caracteres en factores.
    • Nunca cambian el nombre de las variables.
    • Nunca asignan nombres a las filas.

Ejemplo de uso de tibbles

• Ejemplos:

# install.packages("tidyverse")
# install.packages("datos")

library(tidyverse)
library(datos)

flores_df <- datos::flores
flores_tbl <- as_tibble(flores)

Uso del paquete dplyr

Uso de filter()

Selecciona filas en un dataframe

• Uso:

filter(nombre_objeto, condición)

• Anteriormente usamos la sintáxis de R base para hacer algo similar:

imdb[imdb$duration_minutes == 132, c(1:13)] # R Base
df <- filter(imdb, duration_minutes == 132) # dplyr

Uso de select()

Seleccionar o descartar columnas en un dataframe.

• Uso:

select(df, col1, col2)  # Selecciona columnas 1-2
select(df, -col3)  # Selecciona todas las columnas menos col3

• Uso de funciones de selección especiales:

select(df, contains("col"))  # Seleccionar columnas que contienen "col"

• Comparativa:

df[,c("nombre", "edad")]  # R Base
select(df, nombre, edad)  # Tidyverse

Uso de la función mutate()

Transforma valores o crea columnas nuevas.

• Uso:

mutate(df, colum_name = operación)

df$nueva_var <- var + 20  # R base
df <- mutate(df, nueva_var = var + 20) # Tidyverse

Uso de la función rename()

La usamos para renombrar columnas existentes.

• Uso:

rename(df, new_col_name = old_col_name)

• Ejemplo:

imdb$duration_minutes <- imdb$duracion_min # R Base
imdb <- rename(imdb, duracion_min = duration_minutes)  # dplyr

El operador pipe

• El símbolo %>% o |> (entonces o después) es un componente que encadena todas las operaciones de manipulación de datos.

• Ventajas:

  • Nuestro código tiene una grámatica más amigable.
  • No es necesario anidar las llamadas a las funciones.
  • Es más sencillo eliminar/agregar operaciones en nuestro flujo de trabajo sin detener el código.

Ejemplo: Uso del operador pipe

# Nombre del objeto que usamos como insumo
imdb_manipulado <- imdb %>% 
  # Filtramos las películas que duran 132 minutos
  filter(duration_minutes == 132) %>% 
  # Conservamos unicamente el nombre, año y ranking
  select(name, year, rank, duration_minutes) %>% 
  # Creamos una nueva variable (year >=2000)
  mutate(siglo21 = ifelse(year >= 2000, 1, 0)) %>% 
  # Renombramos la variable duration_minutes
  rename(duracion_min = duration_minutes)

• Notas:

  • df solo se menciona una vez al principio (seleccionar y guardar resultados de operaciones).
  • El código termina una vez que dejan de existir |> o %>%.

Tidy Data (Datos ordenados)

• Así, los datos ordenados son datos rectangulares:

Formato de datos (Wide vs. Long)

• En la vida real, los datos no los obtenemos en el formato o estructura que necesitamos para nuestros análisis.
• Un mismo conjunto de datos puede expresarse en un formato ancho o largo:
  • En los datos en formato largo o tidy cada fila es una observación y cada columna es una variable.
  • Los datos en formato ancho pueden ser muy variables pero, en general, cada fila es un item, cada columna es una variable.

tidyr: Ordenando datos desordenados

El paquete tidyr contiene diversas funciones que pueden ser útiles para ordenar y transformar nuestros datos:

• pivot_longer(): Útil para convertir datos en formato wide a long (Ordenar).
• Sintáxis básica:

library(tidyr)

df %>%  
  pivot_longer(cols = c("var1", "var2",...),
               names_to = "col1_name", 
               values_to = "col2_name")

• Donde:
  • cols: El nombre de las columnas a pivotear.
  • names_to: El nombre para la nueva columna de caractéres.
  • values_to: El nombre para la nueva columna de valores.

# Encuesta sobre religión y nivel de ingresos
data("relig_income")
relig_income

# Datos ordenados (formato largo)
df_tidy <- relig_income %>% 
  pivot_longer(-religion, 
               names_to = "income",
               values_to = "count")

# Aumentar el grado de complejidad con Billboard List
data("billboard")

df <- billboard %>% 
  pivot_longer(
    cols = starts_with("wk"), 
    names_to = "Semana",
    values_to = "Ranking",
    values_drop_na = TRUE
  )

tidyr: Ordenando datos desordenados

• pivot_wider(): Útil para convertir datos en formato Long a Wide.
• Sintáxis básica de uso:

library(tidyr)

df %>% 
  pivot_wider(names_from = var1,
              values_from = var2)

• Donde:
  • names_from: La columna cuyos valores serán usados como nombres de columnas.
  • values_from: La columna cuyos valores serán usados como valores de las filas (celdas).

Ejemplo de uso pivot_wider()

# Transformar de datos en formato Long a Wide

data("fish_encounters")

fish_encounters <- fish_encounters %>% 
                      pivot_wider(names_from = station,
                                  values_from = seen)


# No se registra cuando no se vió al pez.
# Podemos intuir que esto es cuando existen NA's

## Completar valores faltantes con 0's

data("fish_encounters")

fish_encounters <- fish_encounters %>% 
                      pivot_wider(names_from = station,
                                  values_from = seen,
                                  values_fill = list(seen = 0))
View(fish_encounters)
# When missing use 0

Ve al Ejercicio #9

Uso de la función group_by()

• Es una función del paquete dplyr que se utiliza para agrupar datos.

• Es útil cuando queremos realizar operaciones en algunos grupos dentro de un conjunto de datos.

• Sintáxis básica:

library(dplyr)

df_agrupado <- df %>%  
                group_by(grupo1, grupo2, ...)

• Donde:
  • df es un conjunto de datos rectangular.
  • grupo1, grupo2,... las columnas a partir de las cuales se quieren agrupar los datos.

Uso de la función summrize()

• Esta función se utiliza para generar resumenes de datos.

• Permite calcular estadísticas descriptivas (promedios, sumas, max, min, etc.) sobre un conjunto de datos agupado.

• Sintáxis básica de uso:

resumen <- df %>% 
            group_by(categoria) %>% 
            summarize(estadistica = funcion(df_columna))

• Donde:
  • df es un conjunto de datos agrupado con la función group_by().
  • estadistica: El nombre de la columna que contendrá el resumen de los datos.
  • funcion(): Cálculo que deseas aplicar p.ej. mean(), sum(), max().

Ejemplo de uso de funciones group_by() y summarize()

# Datos de ejemplo
datos <- tibble(
  categoria = c("A", "A", "B", "B", "C"),
  valor = c(10, 20, 30, 40, 50)
)

# Calcular resumen sin agrupar
resumen_general <- datos %>%
  summarize(promedio_valor = mean(valor))

# Calcular resumen agrupado
resumen_por_categoria <- datos %>%
  group_by(categoria) %>%
  summarize(
    promedio_valor = mean(valor),
    desv_est = sd(valor)
  )

Uniones de datos

• En la práctica las uniones (joins) de datos nos permiten combinar información entre varios objetos.
• La única condición que deben cumplir los datos es que tengan al menos una columna en común.
• En R existen diversos tipos de uniones:
  • Unión a la izquierda (left join).
  • Unión a la derecha (right join).
  • Unión completa (full join).
  • Unión interna (inner join).

Unión a la izquierda (left join)

En una unión a la izquierda de dos tablas L y R, la tabla resultante (llamemosla LR) contendrá todos los registros de la tabla L, pero solo los registros de R cuyas clales (ID) estén incluidas en L.

Unión a la derecha (right join)

En una unión a la derecha la tabla final contendrá todas las filas de R, pero sólo aquellas de L que tengan una clave coincidente. Nótese, que es posible reformular una unión a la derecha de L con R como una a la izquierda de R con L.

Unión completa (full join)

En la unión completa, la tabla resultante contendrá todas las filas de L y todas las de R, con independencia de que no exista una clave coincidente.

Uniones de datos usando R {base}

• Para unir tablas de datos usando R {base} podemos usar la función merge().

  • Sintáxis de uso:

merge(
  x = df1
  y = df2,
  by = "var_id"
)

• Donde:
  • df1 y df2 son las tablas de datos que queremos unir.
  • var_id es la variable en común a partir de la que unimos los datos.

Ejemplo de uso función merge()

# Ejemplo datos ensayo clínico

demographics <- data.frame(
  id = c("P1", "P2", "P3"),
  age = c(40, 54, 47),
  country = c("GER", "JPN", "BRA"),
  stringsAsFactors = FALSE
)
adverse_events <- data.frame(
  id = c("P1", "P1", "P3", "P4"),
  term = c("Headache", "Neutropenia", "Constipation", "Tachycardia"),
  onset_date = c("2020-12-03", "2021-01-03", "2020-11-29", "2021-01-27"),
  stringsAsFactors = FALSE
)

# Ejemplo Unión por la izquierda all.y (derecha)

df_merge <- merge(
  x = demographics,
  y = adverse_events,
  by = "id",
  all.x = TRUE
)

df_merge

# Ejemplo Unión completa

df_merge <- merge(
  x = demographics,
  y = adverse_events,
  by = "id",
  all = TRUE
)

df_merge

Ejemplo de uniones usando dplyr

• En dplyr tenemos una función (verbo) para cada tipo de unión:
  • left_join().
  • right_join().
  • inner_join().
  • full_join().

# Ejemplo de uniones usando dplyr
library(dplyr)
left_join(demographics, adverse_events, by = "id")
inner_join(demographics, adverse_events, by = "id")
full_join(demographics, adverse_events, by = "id")

Ejemplo de unión con dplyr

• En caso de que el nombre de las variables ID de las dos tablas no coincida, tendrás que pasar un vector nombrado como argumento de by.

• Nombre y valor corresponden con la clave en la primera y segunda tabla, respectivamente.

right_join(demographics, adverse_events2, by = c("id" = "pat_id"))